Mi a „->” operátor a C ++ nyelven?

-> nem operátor. Valójában két külön operátorról van szó, - és>.
A feltétel feltétel kódja csökkenti az x értéket, miközben visszaadja x eredeti (nem csökkentett) értékét, majd összehasonlítja az eredeti értéket 0-val a> operátor segítségével.
A jobb megértés érdekében a nyilatkozatot a következőképpen lehet megírni:
míg ((x--)> 0)
|
Vagy valami egészen másért ... x 0-ra csúszik.
míg (x - \
\
\
\
> 0)
printf ("% d", x);
Nem annyira matematikai, de ... minden kép ezer szót fest ...
|
Ez nagyon bonyolult operátor, ezért még az ISO / IEC JTC1 (1. vegyes technikai bizottság) is leírását a C ++ szabvány két különböző részébe helyezte.
Ha viccelődünk, két különböző operátorról van szó: - és> a C ++ 03 szabvány 5.2.6 / 2. És 5.9.
|
Ez egyenértékű
míg (x--> 0)
x-- (utólagos csökkentés) egyenértékű x = x-1-vel, így a kód átalakul:
míg (x> 0) {
x = x-1;
// logika
}
x--; // Az utólagos csökkentés akkor történt, amikor x <= 0
|
x az ellenkező irányban még gyorsabban nullázhat:
int x = 10;
míg (0 <---- x)
{
printf ("% d", x);
}
8 6 4 2
Nyíllal szabályozhatja a sebességet!
int x = 100;
míg (0 <-------------------- x)
{
printf ("% d", x);
}
90 80 70 60 50 40 30 20 10
;)
|
Ez az
#include 
int main (érvénytelen) {
int x = 10;
míg (x--> 0) {// x 0-ra megy
printf ("% d", x);
}
visszatér 0;
}
Csak a szóköz teszi viccesnek a dolgokat, - csökkenti és> összehasonlítja.
|
A -> használatának történelmi jelentősége van. A csökkentés gyorsabb volt (és bizonyos esetekben még mindig van), mint az x86-os architektúrán. A -> használata azt sugallja, hogy x értéke 0 lesz, és a matematikai háttérrel rendelkezők számára szól.
|
míg (x--> 0)
hogyan értelmezik.
|
Teljesen stréber, de ezt fogom használni:
#define as; while
int main (int argc, char * argv [])
{
int n = atoi (argv [1]);
do printf ("n% d \ n", n), mint (n -> 0);
visszatér 0;
}
|
Az egyik könyv, amelyet olvastam (nem emlékszem helyesen, melyik könyvre) kimondta: A fordítók megpróbálják a kifejezéseket a legnagyobb jeligéig elemezni a bal jobb szabály használatával.
Ebben az esetben a következő kifejezés:
x -> 0
A legnagyobb tokenek elemzése:
token 1: x
token 2: -
token 3:>
token 4: 0
következtetni: x--> 0
Ugyanez a szabály vonatkozik erre a kifejezésre:
a ----- b
Elemzés után:
jelző 1: a
token 2: -
token 3: -
token 4: -
token 5: b
következtetni: (a -) - - b
Remélem, ez segít megérteni a bonyolult kifejezést ^^
|
Ez pontosan ugyanaz, mint
míg (x--)
{
printf ("% d", x);
}
nem negatív számok esetén
|
Egyébként van egy "megy" operátorunk. "->" könnyen megjegyezhető irányként, és "míg x nullára megy" jelentése egyenes.
Ezenkívül egy kicsit hatékonyabb, mint egyes platformokon a "for (x = 10; x> 0; x -)" esetében.
|
Ez a kód először összehasonlítja az x-et és a 0-t, majd csökkenti az x-et. (Az első válaszban is elmondta: Az x utólagos csökkentését követi, majd összehasonlítja x és 0 értékeket a> operátorral.) Lásd a kód kimenetét:
9 8 7 6 5 4 3 2 1 0
Most először összehasonlítjuk, majd csökkentjük, ha 0-t látunk a kimenetben.
Ha először csökkenteni, majd összehasonlítani akarjuk, használja ezt a kódot:
#include 
int main (érvénytelen)
{
int x = 10;
míg (--x> 0) // x 0-ra megy
{
printf ("% d", x);
}
visszatér 0;
}
Ez a kimenet:
9 8 7 6 5 4 3 2 1
|
A fordítóm kinyomtatja a 9876543210 kódot, amikor futtatom ezt a kódot.
#include 
int main ()
{
int x = 10;
míg (x -> 0) // x 0-ra megy
{
std :: cout << x;
}
}
Ahogy az várható volt. A while (x--> 0) valójában a (x> 0) -t jelenti. Az x - utólag csökkenti az x értéket.
míg (x> 0)
{
x--;
std :: cout << x;
}
ugyanaz a dolog másfajta írásmódja.
Nagyon szép, hogy az eredeti úgy néz ki, hogy "míg x 0-ra megy".
|
- és> között hiányzik egy szóköz. x utólag csökken, vagyis csökken az x> 0? feltétel ellenőrzése után.
|
- a decrement operátor és> a nagyobb, mint az operátor.
A két operátort egyként alkalmazzák, például ->.
|
Két operátor kombinációja. Először - az érték csökkentésére szolgál, és> annak ellenőrzésére szolgál, hogy az érték nagyobb-e, mint a jobb oldali operandus.
#include 
int main ()
{
int x = 10;
míg (x--> 0)
printf ("% d", x);
visszatér 0;
}
A kimenet a következő lesz:
9 8 7 6 5 4 3 2 1 0
|
Valójában x utólagos csökkentés, és ezzel a feltétellel ellenőrizzük. Ez nem ->, hanem (x--)> 0
Megjegyzés: Az x értéke a feltétel ellenőrzése után megváltozik, mivel az utólagos csökkentést eredményez. Néhány hasonló eset is előfordulhat, például:
-> x -> 0
++> x ++> 0
-> = x -> = 0
++> = x ++> = 0
|
A C és a C ++ betartja a "maximum munch" szabályt. Ugyanígy a --- b fordítás (a--) - b-re, az Ön esetében x -> 0 fordítás (x -)> 0-ra.
A szabály lényegében azt mondja, hogy balról jobbra haladva a kifejezések a maximális karakterszámok felhasználásával jönnek létre, amelyek érvényes kifejezést alkotnak.
|
Miért minden bonyodalom?
Az eredeti kérdésre adott egyszerű válasz:
#include 
int main ()
{
int x = 10;
míg (x>0)
{
printf ("% d", x);
x = x-1;
}
}
Ugyanezt csinálja. Nem azt mondom, hogy így kellene csinálnia, de ugyanazt csinálja, és egy bejegyzésben válaszolt volna a kérdésre.
Az x-- csak a fentiek rövidítése, és> csak egy normál operátornál nagyobb érték. Nincs nagy rejtély!
Túl sok ember bonyolítja az egyszerű dolgokat manapság;)
|
A hagyományos módon meghatároznánk egy feltételet a while ciklus zárójelében () és egy zárójelet a zárójelek belsejében {}, de -> egyszerre definiálja mindkettőt.
Például:
int abc (érvénytelen)
{
int a = 5
míg ((a--)> 0) // Csökkenés és összehasonlítás egyszerre
{
// Kód
}
}
Ez csökkenti az a értéket és lefuttatja a ciklust, miközben az a értéke nagyobb, mint 0.
Hagyományosan ez a következő lenne:
int abc (érvénytelen)
{
int a = 5;
míg (a> 0)
{
a--;
// Kód
}
a--;
}
Mindkét irányban ugyanazt tesszük és ugyanazokat a célokat érjük el.
|
(x -> 0) jelentése (x--> 0).
Használhatja az (x ->) kimenetet: 9 8 7 6 5 4 3 2 1 0
Használhatja (- x> 0). Ez átlag (--x> 0) Kimenet: 9 8 7 6 5 4 3 2 1
Te tudod használni
(- \
\
x> 0)
Kimenet: 9 8 7 6 5 4 3 2 1
Te tudod használni
(\
\
x -> 0)
Kimenet: 9 8 7 6 5 4 3 2 1 0
Te tudod használni
(\
\
x -> 0
\
\
)
Kimenet: 9 8 7 6 5 4 3 2 1 0
Használhatja is
(
x
->
)
Kimenet: 9 8 7 6 5 4 3 2 1 0
Hasonlóképpen, számos módszert kipróbálhat a parancs sikeres végrehajtásához.
|
Itt van - az unária utólagos csökkentési operátor.
míg (x--> 0) // x 0-ra megy
{
printf ("% d", x);
}
Kezdetben az állapot úgy fog értékelni
(x> 0) // 10> 0
Most, hogy a feltétel igaz, csökkentett értékkel kerül a ciklusba
x-- // x = 9
Ezért az első nyomtatott érték 9
Stb. Az utolsó ciklusban x = 1, tehát a feltétel igaz. Az unáris operátornak megfelelően az érték a nyomtatáskor x = 0 értékre változott.
Most x = 0, amely az (x> 0) feltételt hamisnak és a while ciklus kilépésének értékeli.
|
Ez -> egyáltalán nem operátor. Van olyan operátorunk, mint ->, de nem olyan, mint ->. Csak téves értelmezése a (x--> 0) -nak, ami egyszerűen azt jelenti, hogy x rendelkezik a visszavonás utáni operátorral, és ez a hurok addig fut, amíg nagyobb, mint nulla.
A kód írásának másik egyszerű módja a while (x--). A while ciklus akkor áll le, ha hamis feltételt kap, és itt csak egy eset van, azaz 0. Tehát akkor áll le, amikor az x értéket nullára csökkentjük.
|
Nagyon aktív kérdés. Nyerjen 10 hírnevet a kérdés megválaszolásához. A jó hírnév követelménye megvédi ezt a kérdést a spamektől és a nem válaszolóktól.
Nem a keresett válasz? Böngésszen a c ++ c operátorok kódformázási szabványainak való megfeleléssel címkézett egyéb kérdésekben, vagy tegye fel saját kérdését